home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / updates / update14.zoo / lib / diffc < prev    next >
Encoding:
Text File  |  1992-01-15  |  46.8 KB  |  1,761 lines
  1. *** 1.61    1991/09/24 16:44:02
  2. --- Changelo    1992/01/14 18:50:57
  3. ***************
  4. *** 2396,2398 ****
  5. --- 2396,2622 ----
  6.   
  7.   
  8.   ---------------------------- Patchlevel 73 ---------------------------
  9. + 
  10. + popen.c:: ++jrb
  11. +     use tmpnam() to get temp filename. That way $TEMP || $TMPDIR
  12. + get looked up.
  13. + 
  14. + main.c:: ++jrb
  15. +     moved clearing of errno to just before calling main(). otherwise
  16. + somehow is was !=0 at the start of main() in some cases.
  17. + 
  18. + unlink.c:: scott
  19. +     i cant believe this was still lurking in there. Thanks scott!!
  20. +     if the file to be unlinked was open, and we put it in the
  21. +     atexit chain, we were'nt strduping the filename, as a result
  22. +     all filenames in the chain were pointing to the same loc.
  23. +     arrgggh! now strdup() the name, and free it in do_deletes. if
  24. +     the strdup() fails, link it in the chain with a null filename,
  25. +     and in do_deletes() just skip over entries with null
  26. +     filenames. we need to do this as we cannot un-atext the entry,
  27. +     nor do we want to as they may be others in the chain before
  28. +     this one, or successive attempts may succeed.
  29. + 
  30. + main.c:: ++jrb
  31. +     call the atexit functions after closing all the open files.
  32. +     this is essential if the deferred unlinks() etc are going to
  33. +     work.
  34. + 
  35. + binmode.c:: ers
  36. +     new file. as per mntlib pl 13, __default_mode__ is now a 
  37. +         global that the user may define. if not defined by the user
  38. +     it gets picked up from here, with a default value of 0 (text mode)
  39. +     the user may now define __default_mode__ = IOBIN; and that
  40. +     way stdin etc get opened in binary mode. thanks eric.
  41. + 
  42. + fdopen.c fopen.c main.c:: ers
  43. +     adjustments for __default_mode__.
  44. + 
  45. + mincl:: ++jrb
  46. +     add target for binmode.o
  47. + 
  48. + localtim.c:: ers
  49. +     sync with mintlib, use symbolic constants
  50. + 
  51. + main.c,spawnve.c,findfile.c: ers
  52. +       when starting up, convert the environment variable PATH to
  53. +       POSIX form (i.e. using ':' as a separator); when execing a
  54. +       new program, convert back to old form so old programs will
  55. +       work correctly. thanks eric.
  56. + 
  57. + fread.c:: jeffrey jackson (jgj@ssd.csd.harris.com)
  58. +     fread was'nt returning EOF on large reads. thanks jeffrey.
  59. + 
  60. + mktemp.c rename.c symlink.c:: ++jrb
  61. +     save errno around calls to access()
  62. + 
  63. + symlink.c:: jeffrey
  64. +     the length returned was wrong because we were doing a strncpy
  65. +     before strlen.
  66. + 
  67. + main.c:: ++jrb
  68. +     for stdin/out/err set open_stat[].filename to the unix device
  69. +     so that fstat() works. thanks to jeffrey for discovering this.
  70. + 
  71. + pipe.c, close.c::  scott
  72. +     minor fixes for pipes. bash-1.10 works real well now.
  73. + 
  74. + stat.c: jeff
  75. +     handle the case for fstat() when stdin/out etc are re-directed.
  76. +     (ie: open_stat[].filename == NULL).
  77. + 
  78. + unx2dos.c:: jeff
  79. +     overwrite __link_to only once when following links, so that
  80. +     lstat() works correctly.
  81. + 
  82. + symlink.c:: jeff
  83. +     readlink didn't work for symbolic links in root file system if
  84. +     the passed name had the slash.  This was because the slashed 
  85. +     was nulled to create the directory name of the file (boundry
  86. +     condition type bug).
  87. + 
  88. + scanf.c:: ++jrb
  89. +     %n was'nt storing the # of chars read in so far, but was storing
  90. +     number of conversions done. thnaks for allan pratt  for reporting
  91. +     this.
  92. + 
  93. + scanf.c:: ++jrb
  94. +     old one had too many subtle problems. replaced with one from
  95. +     gnu libc with a few subtle corrections, and also a bug fix.
  96. +         NOTES:
  97. +     - interface is different from equivalent gnuC lib function
  98. +           it was munged to match our old _scanf().
  99. +     - if __NO_FLOAT__ is defined then the floating point stuff
  100. +       gets nuked (for iio*.olb) as per our old scanf.c.
  101. + 
  102. +        It is very important to read and understand the GNU Library General 
  103. +        Public License. It specifies rights and conditions that are different
  104. +       from the GNU copyleft.
  105. + 
  106. + atof.c:: ++jrb
  107. +     strtod() was leaving the pointer one char too far when input
  108. +     had a tailing 'e' (for example after 100ergs, the endptr would
  109. +     be pointing to 'r' rather than 'e').
  110. + 
  111. + scanf.c:: ++jrb
  112. +     had to hack it quite a bit to get out bugs. the regression test
  113. +     is great now!
  114. + 
  115. + crt0.c:: ++jrb
  116. +      More meanings for _stksize (thanks to eric and allan for the feedback)
  117. + 
  118. +     _stksize            meaning
  119. +       -4L        keep 3/4, free 1/4, malloc from own heap
  120. +       -3L        keep 2/4 (1/2), free 1/2 malloc from own heap
  121. +       -2L        keep 1/4 of memory, free 3/4, malloc from own heap
  122. + 
  123. +     NOTE: all of the following will do malloc from Malloc() first,
  124. +     when that fails, malloc() will do further mallocs from
  125. +     our own heap. This lets us use the maximum amount of
  126. +       memory in traditional ST's as well as newer split address
  127. +     STs.
  128. + 
  129. +       -1L        keep all of memory (except MINFREE at top) and do
  130. +             mallocs from own heap, with heap grown upwards towards
  131. +             stack, and the stack growing down towards heap,
  132. +             with a minimum slush between them so that they
  133. +             dont meet (only checked while malloc'ing). With
  134. +             this model, further spawning is not possible, but it is
  135. +             well suited for programs such as gcc-cc1 etc.
  136. +             Thanks to Piet van Oostrum & Atze Dijkstra for this idea
  137. + 
  138. +     0L        keep minimum amount of memory. this is also the
  139. +             case when _stksize is undefined by the user.
  140. +     1L        keep 1/4 of memory, free 3/4 ( as in Alcyon GEMSTART)
  141. +     2L        keep 2/4 (1/2), free rest
  142. +     3L        keep 3/4, free 1/4
  143. +     other        keep that many bytes
  144. +     -other        keep |other| bytes and malloc from own heap
  145. + 
  146. + 
  147. +     Also note that when _initial_size is specified, malloc happens from own
  148. +     heap only.
  149. + 
  150. + crt0.c:: ++jrb
  151. +     New convention for ACCs: (the old convention is still supported):
  152. + 
  153. +     If _heapbase is not specified by the user, _stksize bytes will
  154. +     be Malloc()'ed from the system, and _heapbase will be set to
  155. +     this area, and sp will be set to the top of the allocated
  156. +     area. All malloc()'s of course will happen from this local heap.
  157. + 
  158. +     The old convention for ACCs where the _heapbase and _stksize
  159. +     were specified, and sp was set to _heapbase+_stksize will
  160. +     continue to work.
  161. + 
  162. + malloc.c, sbrk.c:: ++jrb
  163. +     implement _split_mem for _stksize >= -1L. get mem from
  164. +     Malloc first, after that is exhausted, start carving out of
  165. +     own heap (the heap will be in the other address space of the
  166. +     split address space). (ie: other to the one the program is
  167. +     launched in). The way this is done is that when _stksize >= -1L
  168. +     in crt0.c the vars _split_mem and _heapbase are set in crt0.c.
  169. +     then whenever we sbrk, we first check _split_mem, which if true
  170. +     causes us to Malloc(). Then when Malloc() fails, and if _split_mem
  171. +     was on, we turn it off and that causes sbrk() to start allocing from
  172. +     heap.
  173. + 
  174. + crt0.c:: ++jrb
  175. +     in _start1() the local vars and args MUST be in registers because
  176. +     we are playing games with SP and the FP. to ensure this use
  177. +     __asm("REG") facility of gcc. thanks allan.
  178. + 
  179. + isatty.c:: ++jrb
  180. +     put in a check so that PRN: always returns false. i believe
  181. +     that this will fix the problem of GS and gnuplot,
  182. +     where fwrite() to a file opened in binary mode to PRN: was munging
  183. +     the bytes on the way to the printer. Unfortunately, i dont
  184. +     have a printer attached to my ST to check.
  185. +     Tim says its ok now. GS works!
  186. + 
  187. + unistd.h, mkdir.c:: andreas schwab
  188. +     mkdir takes a second mode argument (currently ignored).
  189. +     thanks andreas.
  190. + 
  191. + basepage.h:: ers
  192. +     make undocumented parts of the BP hard to get at.
  193. + 
  194. + compiler.h:: ers
  195. +     as per mntlib PL16. note that wchar_t is now an int.
  196. + 
  197. + time.h:: ers
  198. +     per mntlib pl 16
  199. + 
  200. + sys/timeb.h:: ers
  201. +     new file
  202. + 
  203. + timeoday.c:: ers
  204. +     New file.
  205. +     New BSD-ish ftime(), gettimeofday() and settimeofday() system calls.
  206. + 
  207. + mincl:: ers
  208. +     add target for timeoday.
  209. + 
  210. + spawnve.c:: ers
  211. +     use TOS_ARGS instead of NCARGS
  212. + 
  213. + pipe.c:: ers/scott
  214. +     Eric beet down the MiNT/PIPE bug, and I must say with two trivial 
  215. +     changes the dup2/pipe interface works quite well. Under MiNT
  216. +     file handles are not automatically shared with children. So
  217. +     the dup2 in bash/emacs was failing.
  218. + 
  219. + getpass.c, mincl, unistd.h :: ers
  220. +     new file from mintlib for getpass(). Add target to mincl. Add
  221. +     proto to unistd.h. Note: you need to put the final '\n' yourself,
  222. +     after the call to getpass().
  223. + 
  224. + getpass.c:: ++jrb
  225. +     Null terminate return string (was being passed back with \n)
  226. +     If fget retuns a Null pass back Null (per man on the sun).
  227. + 
  228. + gmon.c:: ++jrb
  229. +     we collectively decided that all xbra's should be chained via
  230. +     the next's. make adjustments to unlink_handler.
  231. + 
  232. + ---------------------------- Patchlevel 74 ---------------------------
  233. *** 1.49    1991/09/24 16:44:02
  234. --- PatchLev.h    1992/01/14 18:50:58
  235. ***************
  236. *** 1,5 ****
  237.   
  238. ! #define    PatchLevel "73"
  239.   
  240.   /*
  241.    *
  242. --- 1,5 ----
  243.   
  244. ! #define    PatchLevel "74"
  245.   
  246.   /*
  247.    *
  248. *** 1.18    1991/05/30 04:10:51
  249. --- atof.c    1992/01/14 18:51:05
  250. ***************
  251. *** 239,244 ****
  252. --- 239,245 ----
  253.       register short texp  = 0;
  254.       register short e     = 0;
  255.       double       zero = 0.0;
  256. +     const char        *tmp;
  257.   
  258.       assert ((s != NULL));
  259.   
  260. ***************
  261. *** 280,286 ****
  262.       {
  263.       if(*++s != '\0') /* skip e|E|d|D */
  264.       {  /* ! ([s]xxx[.[yyy]]e)  */
  265. ! 
  266.           while(Isspace(*s)) s++; /* Ansi allows spaces after e */
  267.           if(*s != '\0')
  268.           { /*  ! ([s]xxx[.[yyy]]e[space])  */
  269. --- 281,287 ----
  270.       {
  271.       if(*++s != '\0') /* skip e|E|d|D */
  272.       {  /* ! ([s]xxx[.[yyy]]e)  */
  273. !         tmp = s;
  274.           while(Isspace(*s)) s++; /* Ansi allows spaces after e */
  275.           if(*s != '\0')
  276.           { /*  ! ([s]xxx[.[yyy]]e[space])  */
  277. ***************
  278. *** 303,308 ****
  279. --- 304,310 ----
  280.               texp += e;
  281.           }
  282.           }
  283. +         if(s == tmp) s++;    /* back up pointer for a trailing e|E|d|D */
  284.       }
  285.       }
  286.   
  287. *** 1.12    1991/09/24 16:44:02
  288. --- close.c    1992/01/14 18:51:08
  289. ***************
  290. *** 3,59 ****
  291.    *     Copyright (c) 1988, Memorial University of Newfoundland
  292.    *
  293.    */
  294.   #include    <osbind.h>
  295.   #include    <fcntl.h>
  296.   #include    <device.h>
  297.   #include    <stdlib.h>
  298.   
  299.   #ifdef DEBUG
  300.   #include <stdio.h>
  301.   #endif
  302.   
  303.   int close(fd)
  304. !     int    fd;
  305.   {
  306. !         int     oldfd;
  307. !     extern    int    errno;
  308. !     int        rval;
  309. !     struct _device    *dev;
  310. ! 
  311. !     if ((dev = _dev_fd(fd)) && dev->close)
  312. !         return (*dev->close)(fd);
  313. ! 
  314. !         oldfd = fd;
  315. !     fd = __OPEN_INDEX(fd);
  316. !     if ((fd >= 0) && (fd < __NHANDLES))
  317.       {
  318. !         if (__open_stat[fd].pipe)
  319. !             {
  320.           rval = pipeclose(oldfd);
  321. !         return(rval);
  322. !             }
  323. !             else 
  324.           if((__open_stat[fd].status == FH_ISAFILE) &&
  325.              (__open_stat[fd].filename))
  326.               free(__open_stat[fd].filename);
  327. !         __open_stat[fd].status = FH_UNKNOWN;
  328. !         __open_stat[fd].append = 0;
  329. !         __open_stat[fd].nodelay = 0;
  330. !             __open_stat[fd].pipe = 0;
  331. !         __open_stat[fd].eclose = 0;
  332. !         __open_stat[fd].filename = (char *) 0;
  333. !     }
  334. ! 
  335. !     if ((rval = Fclose(oldfd)) < 0) {
  336. !         errno = -rval;
  337. !         rval = -1;
  338. !     }
  339. ! 
  340. ! 
  341.   #ifdef DEBUG
  342. !     fprintf(stderr, "close(%d)->%d\n", (fd + __SMALLEST_VALID_HANDLE),
  343. !          rval);
  344.   #endif
  345. !     return rval;
  346.   }
  347.   
  348. --- 3,67 ----
  349.    *     Copyright (c) 1988, Memorial University of Newfoundland
  350.    *
  351.    */
  352. + #include     <compiler.h>
  353.   #include    <osbind.h>
  354.   #include    <fcntl.h>
  355.   #include    <device.h>
  356.   #include    <stdlib.h>
  357.   
  358. + __EXTERN int pipeclose __PROTO((int fd));
  359. + 
  360.   #ifdef DEBUG
  361.   #include <stdio.h>
  362.   #endif
  363.   
  364.   int close(fd)
  365. ! int    fd;
  366.   {
  367. !     int     oldfd;
  368. !     extern    int    errno;
  369. !     int        rval;
  370. !     struct _device    *dev;
  371. !     
  372. !     if ((dev = _dev_fd(fd)) && dev->close)
  373. !     return (*dev->close)(fd);
  374. !     oldfd=fd;
  375. !     fd = __OPEN_INDEX(fd);
  376. !     
  377. !     if ((fd >= 0) && (fd < __NHANDLES))
  378. !     {
  379. !     if (__open_stat[fd].pipe)
  380.       {
  381. !         if (oldfd < 3)
  382. !         {
  383. !         __open_stat[fd].pipe = 0;
  384. !         rval = close(oldfd);
  385. !         }
  386. !         else 
  387.           rval = pipeclose(oldfd);
  388. !         return(rval);
  389. !     }
  390. !     else 
  391.           if((__open_stat[fd].status == FH_ISAFILE) &&
  392.              (__open_stat[fd].filename))
  393.               free(__open_stat[fd].filename);
  394. !     __open_stat[fd].status = FH_UNKNOWN;
  395. !     __open_stat[fd].append = 0;
  396. !     __open_stat[fd].nodelay = 0;
  397. !     __open_stat[fd].pipe = 0;
  398. !     __open_stat[fd].eclose = 0;
  399. !     __open_stat[fd].filename = (char *) 0;
  400. !     }
  401. !     
  402. !     if ((rval = Fclose(oldfd)) < 0) {
  403. !     errno = -rval;
  404. !     rval = -1;
  405. !     }
  406. !     
  407.   #ifdef DEBUG
  408. !     fprintf(stderr, "close(%d)->%d\n", (fd + __SMALLEST_VALID_HANDLE),
  409. !         rval);
  410.   #endif
  411. !     return rval;
  412.   }
  413.   
  414. *** 1.17    1991/09/24 16:44:02
  415. --- crt0.c    1992/01/14 18:51:08
  416. ***************
  417. *** 15,21 ****
  418. --- 15,34 ----
  419.    * 01/03/89 ++jrb
  420.    *    The (new) meaning of _stksize: (thanks to allan pratt for the feedback)
  421.    *
  422. +  * 11/27/91 ++jrb
  423. +  *     More meanings for _stksize (thanks to eric and allan for the feedback)
  424. +  *
  425.    *    _stksize            meaning
  426. +  *      -4L        keep 3/4, free 1/4, malloc from own heap
  427. +  *      -3L        keep 2/4 (1/2), free 1/2 malloc from own heap
  428. +  *      -2L        keep 1/4 of memory, free 3/4, malloc from own heap
  429. +  *
  430. +  *    NOTE: all of the following will do malloc from Malloc() first,
  431. +  *    when that fails, malloc() will do further mallocs from
  432. +  *    our own heap. This lets us use the maximum amount of
  433. +  *      memory in traditional ST's as well as newer split address
  434. +  *    STs.
  435. +  *
  436.    *      -1L        keep all of memory (except MINFREE at top) and do
  437.    *            mallocs from own heap, with heap grown upwards towards
  438.    *            stack, and the stack growing down towards heap,
  439. ***************
  440. *** 31,37 ****
  441.    *    2L        keep 2/4 (1/2), free rest
  442.    *    3L        keep 3/4, free 1/4
  443.    *    other        keep that many bytes
  444. !  *    -other        keep all BUT that many bytes
  445.    *
  446.    * 02/14/90 ++jrb (thanks edgar)
  447.    *    auto acc detect
  448. --- 44,50 ----
  449.    *    2L        keep 2/4 (1/2), free rest
  450.    *    3L        keep 3/4, free 1/4
  451.    *    other        keep that many bytes
  452. !  *    -other        keep |other| bytes and malloc from own heap
  453.    *
  454.    * 02/14/90 ++jrb (thanks edgar)
  455.    *    auto acc detect
  456. ***************
  457. *** 52,57 ****
  458. --- 65,73 ----
  459.    *         at startup, sp will be set to top of this area
  460.    *         (_heapbase  + _stksize ) and malloc()'s will happen from heap.
  461.    *        (note malloc() and *not* Malloc())
  462. +  *     OR
  463. +  *    user sets only _stksize. then _heapbase is set to Malloc(_stksize)
  464. +  *    sp to _heapbase + _stksize and mallocs all happen from this heap.
  465.    *
  466.    * 02/16/90 ++jrb
  467.    *  - bug fix: dont get screwed by desktop launch when fast bit is set
  468. ***************
  469. *** 101,106 ****
  470. --- 117,125 ----
  471.   /* are we an app? */
  472.   short _app;
  473.   
  474. + /* are we on a split addr mem ST */
  475. + short _split_mem = 0;
  476. + 
  477.   static void _acc_main __PROTO((void));
  478.   static void _start1 __PROTO((BASEPAGE *bp));
  479.   static long parseargs __PROTO((BASEPAGE *bp));
  480. ***************
  481. *** 148,154 ****
  482. --- 167,189 ----
  483.        jeq    __start0         /* br if prog          */
  484.       tstl    a0@(36)             /* tst parent basepage pointer */
  485.       jne     __start0         /* its a prog if != 0  */
  486. + 
  487. +  /* its an acc, set up a stck+heap */
  488.        movl    a0,__base         /* sto basepage    */
  489. +     tstl    __heapbase         /* setup _heapbase and sp */
  490. +     jne    1f
  491. +     movl    __stksize,d3         /* _heapbase not specified */
  492. +         addql    #3, d3
  493. +     andl    #0xfffffffc,d3
  494. +     movl    d3,sp@-             /* _heapbase = Malloc(_stksize) */
  495. +         movw    #0x48,sp@-
  496. +     trap    #1
  497. +     addqw    #6,sp
  498. +     movl    d0, __heapbase
  499. +     addl    d3,d0
  500. +     movl    d0, sp              /* sp = _heapbase + _stksize */
  501. +     jra    __acc_main
  502. + 1:                     /* heap base specified */
  503.        movl    __heapbase,sp         /* setup sp        */
  504.        addl    __stksize,sp        
  505.        jra    __acc_main");           /* acc main          */
  506. ***************
  507. *** 179,188 ****
  508.   }
  509.   
  510.   static void _start1(bp)
  511. !     register BASEPAGE *bp;
  512.   {
  513. !     register long m;
  514. !     register long freemem;
  515.       
  516.       _app = 1;    /* its an application */
  517.       _base = bp;
  518. --- 214,223 ----
  519.   }
  520.   
  521.   static void _start1(bp)
  522. !     register BASEPAGE *bp __asm("a3");
  523.   {
  524. !     register long m __asm("d3");
  525. !     register long freemem __asm("d4");
  526.       
  527.       _app = 1;    /* its an application */
  528.       _base = bp;
  529. ***************
  530. *** 205,213 ****
  531.           _stksize = _initial_stack;
  532.       }
  533.       
  534.       switch(_stksize)
  535.       {
  536. !       case -1L:    /* keep all but MINFREE, and malloc from own heap */
  537.           _stksize = freemem;
  538.           _heapbase = (void *) ((long)bp->p_tbase + m);
  539.           break;
  540. --- 240,259 ----
  541.           _stksize = _initial_stack;
  542.       }
  543.       
  544. +     if((_stksize < 0) && (_stksize != -1L))
  545. +     {
  546. +         _heapbase = (void *) ((long)bp->p_tbase + m);
  547. +         _stksize = -_stksize - 1;
  548. +         }
  549. +         
  550. +     if((!_initial_stack) && (_stksize >= -1L))
  551. +         {   /* keep all, malloc from Malloc first, then from own heap */
  552. +         _split_mem = 1;
  553. +         }
  554. + 
  555.       switch(_stksize)
  556.       {
  557. !       case -1L:    /* keep all but MINFREE */
  558.           _stksize = freemem;
  559.           _heapbase = (void *) ((long)bp->p_tbase + m);
  560.           break;
  561. ***************
  562. *** 227,238 ****
  563.         case 3L:    /* keep 3/4, free 1/4 */
  564.           _stksize = freemem - (freemem >> 2); 
  565.           break;
  566. !         
  567.         default:
  568. -         if(_stksize < 0) /* keep all but |_stksize| */
  569. -         if((_stksize = freemem + _stksize) <= 0L)
  570. -             goto notenough;
  571.           /* if _stksize > 0, keep that much */
  572.       }
  573.       
  574.   /* make m the total number of bytes including stack */
  575. --- 273,282 ----
  576.         case 3L:    /* keep 3/4, free 1/4 */
  577.           _stksize = freemem - (freemem >> 2); 
  578.           break;
  579. ! 
  580.         default:
  581.           /* if _stksize > 0, keep that much */
  582. +         break;
  583.       }
  584.       
  585.   /* make m the total number of bytes including stack */
  586. *** 1.1    1991/07/23 22:06:28
  587. --- fcntl.c    1992/01/14 18:51:13
  588. ***************
  589. *** 7,12 ****
  590. --- 7,13 ----
  591.   #include <fcntl.h>
  592.   #include <stdarg.h>
  593.   #include <errno.h>
  594. + #include <unistd.h>
  595.   
  596.   #ifdef __STDC__
  597.   int fcntl (int f, int cmd, ...)
  598. *** 1.7    1991/04/26 03:42:08
  599. --- fdopen.c    1992/01/14 18:51:13
  600. ***************
  601. *** 10,16 ****
  602.       register int h;
  603.       const register char *mode;
  604.       {
  605. !     extern int __default_mode__;    /* see fopen.c */
  606.       register int i, iomode = 0, f = __default_mode__;
  607.       register FILE *fp = NULL;
  608.       void _getbuf(FILE *);
  609. --- 10,16 ----
  610.       register int h;
  611.       const register char *mode;
  612.       {
  613. !     extern int __default_mode__;    /* see binmode.c */
  614.       register int i, iomode = 0, f = __default_mode__;
  615.       register FILE *fp = NULL;
  616.       void _getbuf(FILE *);
  617. *** 1.8    1991/04/26 03:42:08
  618. --- findfile.c    1992/01/14 18:51:14
  619. ***************
  620. *** 19,26 ****
  621.   #endif
  622.   
  623.   /* characters used to separate components in a path list */
  624. ! #define PATHSEP1        ','
  625. ! #define PATHSEP2        ';'
  626.   
  627.   /* characters used to separate directory names in a file */
  628.   #define DIRSEP1         '\\'    /* native OS directory separator */
  629. --- 19,26 ----
  630.   #endif
  631.   
  632.   /* characters used to separate components in a path list */
  633. ! #define PATHSEP1        ':'
  634. ! #define PATHSEP2        ','
  635.   
  636.   /* characters used to separate directory names in a file */
  637.   #define DIRSEP1         '\\'    /* native OS directory separator */
  638. *** 1.14    1991/09/24 16:44:02
  639. --- fopen.c    1992/01/14 18:51:15
  640. ***************
  641. *** 13,41 ****
  642.   /* lowest character device handle # */
  643.   #define    LAST_DEVICE    __SMALLEST_VALID_HANDLE
  644.   
  645. ! /*
  646. !  * added _binmode()
  647. !  *    if called with TRUE, then subsequently all fopens have _IOBIN
  648. !  *    by default  on open. This will make life much easier for
  649. !  *    people who have been using the Gnu lib (any my job with the compiler
  650. !  *    much easier too, dont't have to go hunting for fopens())
  651. !  *                ++jrb;
  652. !  */
  653.   
  654. - /* note, cant be static as fdopen.c uses it too, so does libg++ */
  655. - int __default_mode__ = 0;
  656. - 
  657.   static FILE *_fopen __PROTO((const char *filename, const char *mode, FILE *fp));
  658. - 
  659. - void _binmode(force)
  660. - int force;
  661. - {
  662. -     if(force)
  663. -     __default_mode__ = _IOBIN;
  664. -     else
  665. -     __default_mode__ = 0;
  666. - }
  667. - 
  668.   
  669.   static FILE *_fopen(filename, mode, fp)
  670.       const char *filename;
  671. --- 13,21 ----
  672.   /* lowest character device handle # */
  673.   #define    LAST_DEVICE    __SMALLEST_VALID_HANDLE
  674.   
  675. ! extern int __default_mode__;
  676.   
  677.   static FILE *_fopen __PROTO((const char *filename, const char *mode, FILE *fp));
  678.   
  679.   static FILE *_fopen(filename, mode, fp)
  680.       const char *filename;
  681. *** 1.9    1991/04/23 16:04:12
  682. --- fread.c    1992/01/14 18:51:17
  683. ***************
  684. *** 62,68 ****
  685.           }
  686.           else
  687.           { /* read in n bytes into data */
  688. !         l += _read(fp->_file, data, (unsigned long)n);
  689.           }
  690.       }
  691.       ret:
  692. --- 62,75 ----
  693.           }
  694.           else
  695.           { /* read in n bytes into data */
  696. !         if((cnt = _read(fp->_file, data, (unsigned long)n))<=0) {
  697. !             fp->_flag |= ((cnt == 0) ? _IOEOF : _IOERR);
  698. !             goto ret;
  699. !         }
  700. !                 data+=cnt;
  701. !                 l+=cnt;
  702. !                 n-=cnt;
  703. !                 goto again;
  704.           }
  705.       }
  706.       ret:
  707. *** 1.6    1991/06/23 17:07:09
  708. --- gmon.c    1992/01/14 18:51:24
  709. ***************
  710. *** 622,628 ****
  711.       }
  712.       /* otherwise find me in the chain and unlink */
  713.       save_ssp = Super(0L);
  714. !     for(prev = this; this && (this != me); prev = this, this = this->next)
  715.       {
  716.       /* validate the xbra */
  717.       if(this->xbra_magic != _XBRA_MAGIC) 
  718. --- 622,630 ----
  719.       }
  720.       /* otherwise find me in the chain and unlink */
  721.       save_ssp = Super(0L);
  722. !     for(prev = this; this && (this != me); prev = this,
  723. !         this = (xbra_struct *)((this->next)
  724. !          ? (((char *)(this->next)) - offsetof(xbra_struct, jump)) : 0))
  725.       {
  726.       /* validate the xbra */
  727.       if(this->xbra_magic != _XBRA_MAGIC) 
  728. *** 1.6    1991/04/26 03:42:08
  729. --- ioctl.c    1992/01/14 18:51:25
  730. ***************
  731. *** 12,17 ****
  732. --- 12,18 ----
  733.   #include     <osbind.h>
  734.   #include    <device.h>
  735.   #include    <unistd.h>
  736. + #include    <linea.h>    /* for TIOCGWINSZ under TOS */
  737.   
  738.   int
  739.   ioctl(fd, func, arg)
  740. ***************
  741. *** 81,86 ****
  742. --- 82,101 ----
  743.           __tchars[TC_WERASC] = ltc->t_werasc;
  744.           __tchars[TC_LNEXTC] = ltc->t_lnextc;
  745.           break;
  746. + 
  747. +     case TIOCSWINSZ:
  748. +             break;
  749. + 
  750. +     case TIOCGWINSZ:
  751. +         {
  752. +         struct winsize *win = (struct winsize *)arg;
  753. + 
  754. +         (void)linea0();
  755. +         win->ws_row = V_CEL_MY + 1;
  756. +         win->ws_col = V_CEL_MX + 1;
  757. +         win->ws_xpixel = V_X_MAX;
  758. +         win->ws_ypixel = V_Y_MAX;
  759. +         }
  760.   
  761.       default:
  762.           errno = EINVAL;
  763. *** 1.8    1991/04/26 03:42:08
  764. --- isatty.c    1992/01/14 18:51:25
  765. ***************
  766. *** 19,27 ****
  767.     if ((short)handle < 0)
  768.       return(1);
  769.   
  770. !   if ((dev = _dev_fd(fd)) && dev->open)    /* a special device */
  771. !     return 0;
  772. ! 
  773.     if (handle < __NHANDLES)
  774.       if (__open_stat[handle].status != FH_UNKNOWN)
  775.           return(__open_stat[handle].status == FH_ISATTY);
  776. --- 19,30 ----
  777.     if ((short)handle < 0)
  778.       return(1);
  779.   
  780. !   dev = _dev_fd(fd);
  781. !   if (dev && ((dev->open) || (dev->dev == 0xfffd)))
  782. !   {    /* a special device or PRN: */
  783. !       return 0;
  784. !   }
  785. !   
  786.     if (handle < __NHANDLES)
  787.       if (__open_stat[handle].status != FH_UNKNOWN)
  788.           return(__open_stat[handle].status == FH_ISATTY);
  789. *** 1.4    1991/06/11 23:04:27
  790. --- lib.h    1992/01/14 18:51:26
  791. ***************
  792. *** 44,49 ****
  793.   __EXTERN char *_itoa __PROTO((int, char *, int));
  794.   
  795.   #endif /* _LIB_H */
  796. - 
  797. - 
  798. - 
  799. --- 44,46 ----
  800. *** 1.11    1991/04/26 03:42:08
  801. --- localtim.c    1992/01/14 18:51:27
  802. ***************
  803. *** 73,81 ****
  804.       y = (t->tm_mday - 1) + mth_start[t->tm_mon] + /* leap year correction */
  805.           ( ( (t->tm_year % 4) != 0 ) ? 0 : (t->tm_mon > 1) );
  806.   
  807. !     s = (t->tm_sec) + (t->tm_min * 60L) + (t->tm_hour * 3600L) +
  808. !         (y * 86400L) + ((t->tm_year - 70) * 31536000L) +
  809. !         ((t->tm_year - 69)/4) * 86400L;
  810.   
  811.   /* Now adjust for the time zone and possible daylight savings time */
  812.   /* note that we have to call tzset() every time; see 1003.1 sect 8.1.1 */
  813. --- 73,81 ----
  814.       y = (t->tm_mday - 1) + mth_start[t->tm_mon] + /* leap year correction */
  815.           ( ( (t->tm_year % 4) != 0 ) ? 0 : (t->tm_mon > 1) );
  816.   
  817. !     s = (t->tm_sec)+(t->tm_min*SECS_PER_MIN)+(t->tm_hour*SECS_PER_HOUR) +
  818. !         (y*SECS_PER_DAY)+((t->tm_year - 70)*SECS_PER_YEAR) +
  819. !         ((t->tm_year - 69)/4)*SECS_PER_DAY;
  820.   
  821.   /* Now adjust for the time zone and possible daylight savings time */
  822.   /* note that we have to call tzset() every time; see 1003.1 sect 8.1.1 */
  823. *** 1.19    1991/05/23 14:43:17
  824. --- main.c    1992/01/14 18:51:27
  825. ***************
  826. *** 54,59 ****
  827. --- 54,62 ----
  828.   /* supplied by the user */
  829.   __EXTERN int main __PROTO((int, char **, char **));
  830.   
  831. + /* in getbuf.c */
  832. + __EXTERN void _getbuf __PROTO((FILE *));
  833. + 
  834.   void
  835.   _main(_argc, _argv, _envp)
  836.       long _argc;
  837. ***************
  838. *** 62,69 ****
  839.       char *tty;
  840.       register FILE *f;
  841.       register int i;
  842. !     void _getbuf(FILE *);
  843. !     extern int __default_mode__;
  844.       int main(int, char **, char **);
  845.   
  846.       _start_time = 0;    /* for dumped prgs */
  847. --- 65,72 ----
  848.       char *tty;
  849.       register FILE *f;
  850.       register int i;
  851. !      char *s, *t, *new;
  852. !     extern int __default_mode__; /* in binmode.c or defined by user */
  853.       int main(int, char **, char **);
  854.   
  855.       _start_time = 0;    /* for dumped prgs */
  856. ***************
  857. *** 70,76 ****
  858.       _start_time = clock();
  859.       _child_runtime = _sys_runtime = 0;
  860.       num_at_exit = 0;
  861. -     errno = 0;
  862.   /*
  863.    * check for MiNT
  864.    */
  865. --- 73,78 ----
  866. ***************
  867. *** 97,107 ****
  868.       if(!*_argv[0] && isatty(2))
  869.           (void)Fforce(2, _console_dev - 3);
  870.   
  871. - /*
  872. -  * FIX_ME: we should check to see if _binmode(TRUE) was set because
  873. -  * of UNIXMODE.
  874. -  */
  875. - 
  876.       stdin->_flag = _IOREAD|_IOFBF|__default_mode__;
  877.       stdout->_flag = _IOWRT|_IOLBF|__default_mode__;
  878.       stderr->_flag = _IORW|_IONBF|__default_mode__;
  879. --- 99,104 ----
  880. ***************
  881. *** 120,126 ****
  882.       }
  883.   
  884.       for(i = 0; i <= __OPEN_INDEX(2); i++) {
  885. !         __open_stat[i].filename = NULL;
  886.       }
  887.   
  888.        for(i = 3; i < _NFILE; i++, f++) {
  889. --- 117,125 ----
  890.       }
  891.   
  892.       for(i = 0; i <= __OPEN_INDEX(2); i++) {
  893. !         __open_stat[i].filename = isatty(i) ? 
  894. !             ((_console_dev == 2) ? "/dev/console" : "/dev/tty1")
  895. !                 : (char *)NULL; /* if it was re-dir */
  896.       }
  897.   
  898.        for(i = 3; i < _NFILE; i++, f++) {
  899. ***************
  900. *** 127,132 ****
  901. --- 126,165 ----
  902.         f->_flag = 0;        /* clear flags, if this is a dumped program */
  903.       }
  904.   
  905. +     /* Fix up environment, if necessary. At present, the only variable
  906. +      * affected is PATH; the "standard" path separators for PATH are
  907. +      * ',' and ';' in the Atari world, but POSIX mandates ':'. This
  908. +      * conflicts with the use of ':' as a drive separator, so we
  909. +      * also convert names like A:\foo to /dev/A/foo
  910. +      * NOTE: this conversion must be undone in spawn.c so that
  911. +      * old fashioned programs will understand us!
  912. +      */
  913. +     for (i = 0; s = _envp[i]; i++) {    /* '=', NOT '==' */
  914. +         if (s[0] == 'P' && s[1] == 'A' && s[2] == 'T' &&
  915. +             s[3] == 'H' && s[4] == '=') {
  916. +             new = alloca(4*strlen(s));
  917. +             strncpy(new, s, 5);
  918. +             t = new+5;
  919. +             s += 5;
  920. +             while (*s) {
  921. +                 if (s[1] == ':') {    /* drive letter */
  922. +                     *t++ = '/';
  923. +                     *t++ = 'd'; *t++ = 'e'; *t++ = 'v';
  924. +                     *t++ = '/'; *t++ = *s++; s++;
  925. +                 } else if (*s == ';' || *s == ',') {
  926. +                     *t++ = ':'; s++;
  927. +                 } else {
  928. +                     *t++ = *s++;
  929. +                 }
  930. +             }
  931. +             *t++ = 0;
  932. +             _envp[i] = strdup(new);
  933. +             break;
  934. +         }
  935. +     }
  936. + 
  937. +     errno = 0;
  938. + 
  939.       /* ANSI-Draft: A return from the initial call to the main      */
  940.       /* function is equivalent to calling the exit function with    */
  941.       /* the value returned by the main function as its argument. If */
  942. ***************
  943. *** 147,154 ****
  944.   {
  945.       register int i, f;
  946.   
  947. -     for(i = num_at_exit - 1; i >= 0; --i)
  948. -         (*_at_exit[i])();
  949.   
  950.       for(i=0; i<_NFILE; ++i) {
  951.           f = _iob[i]._flag;
  952. --- 180,185 ----
  953. ***************
  954. *** 158,163 ****
  955. --- 189,198 ----
  956.               else
  957.                   fclose(&_iob[i]);
  958.       }
  959. + 
  960. +     for(i = num_at_exit - 1; i >= 0; --i)
  961. +         (*_at_exit[i])();
  962. + 
  963.       _exit(status);
  964.   }
  965.   
  966. *** 1.17    1991/09/24 16:44:02
  967. --- malloc.c    1992/01/14 18:51:28
  968. ***************
  969. *** 46,51 ****
  970. --- 46,52 ----
  971.     struct mem_chunk *p, *q;
  972.     long sz;
  973.     extern void *_heapbase;
  974. +   extern short _split_mem;
  975.   
  976.   /* add a mem_chunk to required size and round up */
  977.     n = n + sizeof(struct mem_chunk);
  978. ***************
  979. *** 63,69 ****
  980.   /* if not enough memory, get more from the system */
  981.     if (q == NULL) 
  982.       {
  983. !     if ((_heapbase != NULL) || (n > MINHUNK))
  984.           sz = n;
  985.       else {
  986.           sz = MINHUNK;
  987. --- 64,70 ----
  988.   /* if not enough memory, get more from the system */
  989.     if (q == NULL) 
  990.       {
  991. !     if (((!_split_mem) && (_heapbase != NULL)) || (n > MINHUNK))
  992.           sz = n;
  993.       else {
  994.           sz = MINHUNK;
  995. ***************
  996. *** 108,113 ****
  997. --- 109,115 ----
  998.     struct mem_chunk *o, *p, *q, *s;
  999.     struct mem_chunk *r = (struct mem_chunk *) param;
  1000.     extern void *_heapbase;
  1001. +   extern short _split_mem;
  1002.   
  1003.   /* free(NULL) should do nothing */
  1004.     if (r == 0)
  1005. ***************
  1006. *** 155,161 ****
  1007.       r->size = 0;
  1008.       r->next = NULL;
  1009.       s = (struct mem_chunk * )(((long) p) + p->size);
  1010. !     if (_heapbase != NULL && s >= (struct mem_chunk *) _heapbase) {
  1011.         assert(s == _heapbase);
  1012.         _heapbase = (char *) p;
  1013.         _stksize += p->size;
  1014. --- 157,163 ----
  1015.       r->size = 0;
  1016.       r->next = NULL;
  1017.       s = (struct mem_chunk * )(((long) p) + p->size);
  1018. !     if ((!_split_mem) && _heapbase != NULL && s >= (struct mem_chunk *) _heapbase) {
  1019.         assert(s == _heapbase);
  1020.         _heapbase = (char *) p;
  1021.         _stksize += p->size;
  1022. ***************
  1023. *** 165,171 ****
  1024.       else
  1025.           {
  1026.         s = (struct mem_chunk * )(((long) r) + r->size);
  1027. !       if (_heapbase != NULL && s >= (struct mem_chunk *) _heapbase) {
  1028.           assert(s == _heapbase);
  1029.           _heapbase = (char *) r;
  1030.           _stksize += r->size;
  1031. --- 167,173 ----
  1032.       else
  1033.           {
  1034.         s = (struct mem_chunk * )(((long) r) + r->size);
  1035. !       if ((!_split_mem) && _heapbase != NULL && s >= (struct mem_chunk *) _heapbase) {
  1036.           assert(s == _heapbase);
  1037.           _heapbase = (char *) r;
  1038.           _stksize += r->size;
  1039. *** 1.12    1991/09/24 16:44:02
  1040. --- mincl    1992/01/14 18:51:30
  1041. ***************
  1042. *** 13,19 ****
  1043.   
  1044.   GCC=     $(GLIB1) $(GLIB2) \
  1045.       ldexp.o frexp.o modf.o alloca.o setjmp.o osbind.o\
  1046. !     linea.o  alglobal.o sysvar.o gmon.o screen.o stksiz.o
  1047.   #
  1048.   # ANSI stuff + support
  1049.   ANSI =  atol.o atof.o abort.o bsearch.o clock.o ctime.o ctype.o difftime.o \
  1050. --- 13,19 ----
  1051.   
  1052.   GCC=     $(GLIB1) $(GLIB2) \
  1053.       ldexp.o frexp.o modf.o alloca.o setjmp.o osbind.o\
  1054. !     linea.o  alglobal.o sysvar.o gmon.o screen.o stksiz.o binmode.o
  1055.   #
  1056.   # ANSI stuff + support
  1057.   ANSI =  atol.o atof.o abort.o bsearch.o clock.o ctime.o ctype.o difftime.o \
  1058. ***************
  1059. *** 31,38 ****
  1060.   #
  1061.   # other portable stuff
  1062.   PORT =  alphasor.o abs.o catch.o dirent.o findfile.o ftw.o getpw.o \
  1063. !     getlogin.o getopt.o ident.o mktemp.o scandir.o strlwr.o strrev.o \
  1064. !     regexp.o regsup.o textio.o random.o
  1065.   
  1066.   #
  1067.   # the string library
  1068. --- 31,38 ----
  1069.   #
  1070.   # other portable stuff
  1071.   PORT =  alphasor.o abs.o catch.o dirent.o findfile.o ftw.o getpw.o \
  1072. !     getlogin.o getopt.o getpass.o ident.o mktemp.o scandir.o strlwr.o \
  1073. !     strrev.o regexp.o regsup.o textio.o random.o
  1074.   
  1075.   #
  1076.   # the string library
  1077. ***************
  1078. *** 49,55 ****
  1079.       link.o lseek.o mkdir.o null.o open.o perror.o pipe.o popen.o psignal.o \
  1080.       read.o rename.o rmdir.o \
  1081.       sbrk.o sgtty.o signal.o siglist.o sleep.o spawnve.o spawnvp.o stat.o \
  1082. !     symdir.o symlink.o tchars.o time.o times.o \
  1083.       unlink.o unx2dos.o utime.o vfork.o write.o
  1084.   
  1085.   #
  1086. --- 49,55 ----
  1087.       link.o lseek.o mkdir.o null.o open.o perror.o pipe.o popen.o psignal.o \
  1088.       read.o rename.o rmdir.o \
  1089.       sbrk.o sgtty.o signal.o siglist.o sleep.o spawnve.o spawnvp.o stat.o \
  1090. !     symdir.o symlink.o tchars.o time.o timeoday.o times.o \
  1091.       unlink.o unx2dos.o utime.o vfork.o write.o
  1092.   
  1093.   #
  1094. *** 1.8    1991/06/11 23:04:27
  1095. --- mkdir.c    1992/01/14 18:51:31
  1096. ***************
  1097. *** 11,18 ****
  1098.   
  1099.   extern int errno;
  1100.   
  1101. ! int mkdir(_path)
  1102.   const char *_path;
  1103.   {
  1104.       int rv, name_munged;
  1105.       char path[FILENAME_MAX];
  1106. --- 11,19 ----
  1107.   
  1108.   extern int errno;
  1109.   
  1110. ! int mkdir(_path, mode)
  1111.   const char *_path;
  1112. + int mode;
  1113.   {
  1114.       int rv, name_munged;
  1115.       char path[FILENAME_MAX];
  1116. *** 1.9    1991/05/23 14:43:17
  1117. --- mktemp.c    1992/01/14 18:51:31
  1118. ***************
  1119. *** 8,13 ****
  1120. --- 8,14 ----
  1121.   #include <fcntl.h>
  1122.   #include <unistd.h>
  1123.   #include <assert.h>
  1124. + #include <errno.h>
  1125.   #include "lib.h"
  1126.   
  1127.   #define TEN_MUL(X)    ((((X) << 2) + (X)) << 1)
  1128. ***************
  1129. *** 18,23 ****
  1130. --- 19,25 ----
  1131.     char * p, * q;
  1132.     long tempnum, nx;
  1133.     static int startat = 0;
  1134. +   int save_errno;
  1135.   
  1136.     assert((pattern != NULL));
  1137.   
  1138. ***************
  1139. *** 39,49 ****
  1140. --- 41,56 ----
  1141.     }
  1142.     else 
  1143.         startat++;
  1144. +   save_errno = errno;
  1145.     for(; tempnum < nx; tempnum++)
  1146.     {
  1147.       (void) _ltoa(tempnum, q, 10); /* assumption: strrev reverses in place */
  1148.       if(access(pattern, F_OK))    /* using access takes care of unx2dos also */
  1149. +     {
  1150. +     errno = save_errno;
  1151.       return pattern;
  1152. +     }
  1153.     }
  1154. +   errno = save_errno;
  1155.     return NULL;
  1156.   }
  1157. *** 1.1    1991/09/24 16:44:02
  1158. --- pipe.c    1992/01/14 18:51:33
  1159. ***************
  1160. *** 4,10 ****
  1161. --- 4,14 ----
  1162.   #include <errno.h>
  1163.   #include <stdio.h>
  1164.   #include <stdlib.h>
  1165. + #define __MINT__
  1166. + #include <mintbind.h>
  1167.   
  1168. + extern int __mint;
  1169. + 
  1170.   /**
  1171.    ** (sjk)++ These routines simulate a eunchs pipe() call using temporary 
  1172.    **         files. A linked list of type *_pipe is kept as to allow as 
  1173. ***************
  1174. *** 23,28 ****
  1175. --- 27,33 ----
  1176.              struct _pipe *next;
  1177.                };
  1178.   static struct _pipe *__pipes = NULL;
  1179. + static int del_list (struct _pipe *);
  1180.   
  1181.   /*---------------------------------------------------------------------------*/
  1182.   /* Make a pipe, open the tempory file, set it up for writing, add the pipe   */
  1183. ***************
  1184. *** 41,46 ****
  1185. --- 46,55 ----
  1186.     /*----------------------------------------------*/
  1187.     fd = open(name,O_CREAT | O_TRUNC | O_RDWR | O_PIPE, 0644); 
  1188.   
  1189. + #if defined(DEBUG)
  1190. +   fprintf(stderr,"opened pipe - fd : %d.\n",fd);
  1191. + #endif
  1192. + 
  1193.     if (fd < 0)
  1194.       fprintf(stderr,"fd returns : %d! PIPE(%s) failed.\n",fd, name);
  1195.     else 
  1196. ***************
  1197. *** 60,65 ****
  1198. --- 69,76 ----
  1199.         __pipes     = p;
  1200.         /*-------------------------------------------------------------------*/ 
  1201.         fildes[0] = fildes[1] = fd;       /* we fill in fildes[].            */
  1202. +       if (__mint)
  1203. +     Fcntl(fd,0L,2);                 /* Make fd shared across Pexecs()  */
  1204.       }
  1205.     return(fd);                           /* Return the file descriptor.     */
  1206.   }
  1207. ***************
  1208. *** 77,82 ****
  1209. --- 88,97 ----
  1210.      int    ifd;
  1211.      for (p=__pipes; p; p=p->next)
  1212.       { if (fd == p->file_des) 
  1213. +        { 
  1214. + #if defined(DEBUG)
  1215. +         fprintf(stderr,"Deleting pipe - mode : %c, fd : %d\n",p->flag,fd);
  1216. + #endif
  1217.           if (p->flag == 'r') 
  1218.         { int res;
  1219.           ifd = __OPEN_INDEX(fd);
  1220. ***************
  1221. *** 92,97 ****
  1222. --- 107,113 ----
  1223.               lseek(p->file_des,0,SEEK_SET);         /* read from the start.  */
  1224.               return(0);
  1225.             }
  1226. +       }
  1227.       }
  1228.      fprintf(stderr,"attempt to close nonexistant pipe.\n");
  1229.      return(-1);
  1230. ***************
  1231. *** 100,106 ****
  1232.   /*---------------------------------------------------------------------*/
  1233.   /* delete a pipe descriptor from our list of pipes rooted ar __pipes.  */
  1234.   /*---------------------------------------------------------------------*/
  1235. ! del_list(p)
  1236.   struct _pipe *p;
  1237.   { struct _pipe *q,*r;
  1238.     
  1239. --- 116,122 ----
  1240.   /*---------------------------------------------------------------------*/
  1241.   /* delete a pipe descriptor from our list of pipes rooted ar __pipes.  */
  1242.   /*---------------------------------------------------------------------*/
  1243. ! static int del_list(p)
  1244.   struct _pipe *p;
  1245.   { struct _pipe *q,*r;
  1246.     
  1247. ***************
  1248. *** 110,116 ****
  1249.         return(0);
  1250.       }
  1251.     else 
  1252. !     { r = p->next; q = p;               /* No it is interior.           */
  1253.         for (; r; r = r->next)
  1254.           { if (r == p)
  1255.              { q->next = r->next;              /* pass over it.   */
  1256. --- 126,132 ----
  1257.         return(0);
  1258.       }
  1259.     else 
  1260. !     { r = __pipes->next; q = __pipes;    /* No it is interior.           */
  1261.         for (; r; r = r->next)
  1262.           { if (r == p)
  1263.              { q->next = r->next;              /* pass over it.   */
  1264. ***************
  1265. *** 121,125 ****
  1266.       }
  1267.       }
  1268.     fprintf(stderr,"Attempt to delete a nonexisting pipe form list (__pipes).");
  1269.   }
  1270. - 
  1271. --- 137,141 ----
  1272.       }
  1273.       }
  1274.     fprintf(stderr,"Attempt to delete a nonexisting pipe form list (__pipes).");
  1275. +   return(-1);
  1276.   }
  1277. *** 1.3    1991/04/12 18:19:53
  1278. --- popen.c    1992/01/14 18:51:33
  1279. ***************
  1280. *** 29,35 ****
  1281.       char    pmode;        /* "r" or "w" to/from the pipe ?    */
  1282.       char    *pcommand;    /* cmd to execute (only for "w")    */
  1283.       int    pstat;        /* exit code of cmd (only for "r")    */
  1284. !     char    pname[20];    /* temp filename. 20 should be enough...*/
  1285.       FILE    *pfile;        /* pipe identifier            */
  1286.       struct _pipe    *pnext;    /* next pipe in the list.        */
  1287.       };
  1288. --- 29,35 ----
  1289.       char    pmode;        /* "r" or "w" to/from the pipe ?    */
  1290.       char    *pcommand;    /* cmd to execute (only for "w")    */
  1291.       int    pstat;        /* exit code of cmd (only for "r")    */
  1292. !     char    pname[32];    /* temp filename. 32 should be enough...*/
  1293.       FILE    *pfile;        /* pipe identifier            */
  1294.       struct _pipe    *pnext;    /* next pipe in the list.        */
  1295.       };
  1296. ***************
  1297. *** 36,43 ****
  1298.   
  1299.   static struct _pipe    *__pipes = NULL;    /* head of pipe list    */
  1300.   
  1301. - static char        ptmp[] = "pipeXXXX";    /* skeleton for temp filename */
  1302. - 
  1303.   /* open a pipe to the command argument in the mode given by the type string.
  1304.    * If caller wants to read the pipe, redirect output and execute command,
  1305.    * then open the temp file and return that. If caller wants to write to
  1306. --- 36,41 ----
  1307. ***************
  1308. *** 55,64 ****
  1309.       /* initialize the new pipe entry */
  1310.       p->pmode = *type;
  1311.       p->pfile = (FILE *) NULL;
  1312. !     strcpy(p->pname,ptmp);
  1313. !     mktemp(p->pname);
  1314.       /* make command line with appropriate re-direction */
  1315. !     if((p->pcommand = (char *)malloc(strlen(command)+strlen(ptmp)+4L))
  1316.           == (char *)NULL)
  1317.       {    /* no  mem */
  1318.           free(p);
  1319. --- 53,61 ----
  1320.       /* initialize the new pipe entry */
  1321.       p->pmode = *type;
  1322.       p->pfile = (FILE *) NULL;
  1323. !     (void)tmpnam(p->pname);
  1324.       /* make command line with appropriate re-direction */
  1325. !     if((p->pcommand = (char *)malloc(strlen(command)+strlen(p->pname)+4L))
  1326.           == (char *)NULL)
  1327.       {    /* no  mem */
  1328.           free(p);
  1329. *** 1.13    1991/06/11 23:04:27
  1330. --- rename.c    1992/01/14 18:51:35
  1331. ***************
  1332. *** 18,23 ****
  1333. --- 18,24 ----
  1334.       SYMDIR *olddir = 0, *newdir = 0;
  1335.       SYMENTRY *ent = 0, *old;
  1336.       char *s;
  1337. +     int save_errno = errno;
  1338.   
  1339.       if (!access(_newname, 0)) {    /* new name already exists */
  1340.   #ifdef DEBUG
  1341. ***************
  1342. *** 26,31 ****
  1343. --- 27,33 ----
  1344.           if (unlink(_newname))
  1345.               return -1;
  1346.       }
  1347. +     errno = save_errno;
  1348.   
  1349.       rval = unx2dos(_oldname, oldname);
  1350.       /* unx2dos returns _NM_LINK and sets __link_path and __link_name if
  1351. *** 1.7    1991/06/23 17:07:09
  1352. --- sbrk.c    1992/01/14 18:51:36
  1353. ***************
  1354. *** 15,20 ****
  1355. --- 15,21 ----
  1356.   
  1357.   extern void *_heapbase;
  1358.   extern long _stksize;
  1359. + extern short _split_mem;
  1360.   
  1361.   static void * HeapAlloc( sz )
  1362.   size_t sz ;
  1363. ***************
  1364. *** 43,49 ****
  1365.   {
  1366.     void *rval;
  1367.   
  1368. !   if(_heapbase != NULL)
  1369.     {
  1370.         if(n) rval = HeapAlloc(n);
  1371.         else  rval = _heapbase;
  1372. --- 44,50 ----
  1373.   {
  1374.     void *rval;
  1375.   
  1376. !   if((!_split_mem) && (_heapbase != NULL))
  1377.     {
  1378.         if(n) rval = HeapAlloc(n);
  1379.         else  rval = _heapbase;
  1380. ***************
  1381. *** 54,59 ****
  1382. --- 55,65 ----
  1383.     }
  1384.     if (rval == NULL)
  1385.     {
  1386. +       if(_split_mem)
  1387. +       {  /* now switch over to own heap for further requests, including this one */
  1388. +       _split_mem = 0;
  1389. +       return lsbrk(n);
  1390. +       }
  1391.         errno = ENOMEM;
  1392.         rval = (void *)-1;
  1393.     }
  1394. *** 1.14    1991/07/23 22:06:28
  1395. --- spawnve.c    1992/01/14 18:51:39
  1396. ***************
  1397. *** 22,27 ****
  1398. --- 22,28 ----
  1399.   #include    <time.h>
  1400.   #include    <string.h>
  1401.   #include    <fcntl.h>
  1402. + #include    <unistd.h>
  1403.   #include    "lib.h"
  1404.   
  1405.   extern char **environ;
  1406. ***************
  1407. *** 29,35 ****
  1408.   clock_t _child_runtime;
  1409.   clock_t _sys_runtime;
  1410.   
  1411. ! static    char    cmd[NCARGS+1];
  1412.   
  1413.   /*
  1414.    * FIXME: currently mode == P_OVERLAY doesn't work as advertised, i.e. it
  1415. --- 30,37 ----
  1416.   clock_t _child_runtime;
  1417.   clock_t _sys_runtime;
  1418.   
  1419. ! #define TOS_ARGS 126
  1420. ! static    char    cmd[TOS_ARGS+1];
  1421.   
  1422.   /*
  1423.    * FIXME: currently mode == P_OVERLAY doesn't work as advertised, i.e. it
  1424. ***************
  1425. *** 73,85 ****
  1426.           return -1;
  1427.       }
  1428.       s = env;
  1429. !     while (*envp) {
  1430. !         for (p = *envp ; *p ; )
  1431. !             *s++ = *p++;
  1432.           *s++ = '\0';
  1433.           envp++;
  1434.       }
  1435. -     
  1436.       strcpy(s, "ARGV=");
  1437.       s += 6; /* s+=sizeof("ARGV=") */
  1438.   
  1439. --- 75,108 ----
  1440.           return -1;
  1441.       }
  1442.       s = env;
  1443. !     while ((p = *envp) != 0) {
  1444. ! /*
  1445. !  * NOTE: in main.c, we converted the PATH environment variable into
  1446. !  * POSIX form. Here, we convert back into gulam form. Note that the
  1447. !  * new variable will be shorter than the old, so space is not a problem.
  1448. !  */
  1449. !         if (!strncmp(p, "PATH=", 5)) {
  1450. !             strncpy(s, p, 5); s += 5; p += 5;
  1451. !             while (*p) {
  1452. !                 if (!strncmp(p, "/dev/", 5) && p[5]) {
  1453. !                     *s++ = p[5];
  1454. !                     *s++ = ':';
  1455. !                     p += 6;
  1456. !                 } else if (*p == ':') {
  1457. !                     *s++ = ','; p++;
  1458. !                 } else if (*p == '/') {
  1459. !                     *s++ = '\\'; p++;
  1460. !                 } else {
  1461. !                     *s++ = *p++;
  1462. !                 }
  1463. !             }
  1464. !         } else {
  1465. !             while(*p)
  1466. !                 *s++ = *p++;
  1467. !         }
  1468.           *s++ = '\0';
  1469.           envp++;
  1470.       }
  1471.       strcpy(s, "ARGV=");
  1472.       s += 6; /* s+=sizeof("ARGV=") */
  1473.   
  1474. ***************
  1475. *** 100,111 ****
  1476.           while (*++argv) {
  1477.               p = *argv;
  1478.               while (*p) {
  1479. !                               if (cmlen <= NCARGS) {
  1480.                                         *t++ = *p; cmlen++;
  1481.                                 }
  1482.                   *s++ = *p++;
  1483.               }
  1484. !                         if (cmlen <= NCARGS && *(argv+1)) {
  1485.                                   *t++ = ' '; cmlen++;
  1486.                           }
  1487.                   *s++ = '\0';
  1488. --- 123,134 ----
  1489.           while (*++argv) {
  1490.               p = *argv;
  1491.               while (*p) {
  1492. !                               if (cmlen <= TOS_ARGS) {
  1493.                                         *t++ = *p; cmlen++;
  1494.                                 }
  1495.                   *s++ = *p++;
  1496.               }
  1497. !                         if (cmlen <= TOS_ARGS && *(argv+1)) {
  1498.                                   *t++ = ' '; cmlen++;
  1499.                           }
  1500.                   *s++ = '\0';
  1501. *** 1.15    1991/07/23 22:06:28
  1502. --- stat.c    1992/01/14 18:51:40
  1503. ***************
  1504. *** 245,251 ****
  1505.       int old;
  1506.       int r;
  1507.       struct _device *dev = _dev_fd(fd);
  1508. ! 
  1509.       if(dev)
  1510.       {
  1511.       char *devname = (char *)alloca(strlen(dev->unxnm) + 6L);
  1512. --- 245,251 ----
  1513.       int old;
  1514.       int r;
  1515.       struct _device *dev = _dev_fd(fd);
  1516. !     
  1517.       if(dev)
  1518.       {
  1519.       char *devname = (char *)alloca(strlen(dev->unxnm) + 6L);
  1520. ***************
  1521. *** 253,270 ****
  1522.       (void) strcat(devname, dev->unxnm);
  1523.       return stat(devname, st);
  1524.       }
  1525. ! 
  1526.       fd = __OPEN_INDEX(fd);
  1527.       if((fd >= 0) && (fd < __NHANDLES))
  1528.       {
  1529. ! /* we should turn off links, because the name we're going to give
  1530. !  * to 'stat' has already been unx2dos'd
  1531. !  */
  1532. !     old = _lOK;
  1533. !     _lOK = 0;
  1534. !     r = stat(__open_stat[fd].filename, st);
  1535. !     _lOK = old;
  1536. !     return r;
  1537.       }
  1538.       errno = EBADF;
  1539.       return -1;
  1540. --- 253,323 ----
  1541.       (void) strcat(devname, dev->unxnm);
  1542.       return stat(devname, st);
  1543.       }
  1544. !     
  1545.       fd = __OPEN_INDEX(fd);
  1546.       if((fd >= 0) && (fd < __NHANDLES))
  1547.       {
  1548. !     if (__open_stat[fd].filename) {
  1549. !         /* we should turn off links, because the name we're going to give
  1550. !          * to 'stat' has already been unx2dos'd
  1551. !          */
  1552. !         old = _lOK;
  1553. !         _lOK = 0;
  1554. !         r = stat(__open_stat[fd].filename, st);
  1555. !         _lOK = old;
  1556. !         return r;
  1557. !     } else {
  1558. !         _DOSTIME timestruct;
  1559. !         
  1560. !         /* the following code is stolen from Eric R. Smith */
  1561. !         r = Fdatime(×truct, fd, 0);
  1562. !         if (r < 0) {            /* assume TTY */
  1563. !         st->st_mode = S_IFCHR | 0600;
  1564. !         st->st_attr = 0;
  1565. !         st->st_mtime = st->st_ctime = st->st_atime =
  1566. !             time((time_t *)0) - 2;
  1567. !         st->st_size = 0;
  1568. !         } else {
  1569. !         long oldplace;
  1570. !         
  1571. !         st->st_mtime = st->st_atime = st->st_ctime =
  1572. !             unixtime(timestruct.time,timestruct.date);
  1573. !         st->st_mode = S_IFREG | 0644;        /* this may be false */
  1574. !         st->st_attr = 0;            /* because this is */
  1575. !         
  1576. !         /* get current file location */
  1577. !         oldplace = Fseek(0L, fd, SEEK_CUR);
  1578. !         if (oldplace < 0) {        /* can't seek -- must be pipe */
  1579. !             st->st_mode = S_IFIFO | 0644;
  1580. !             st->st_size = 1024;
  1581. !         } else {
  1582. !             short magic;
  1583. !             r = Fseek(0L, fd, SEEK_END);    /* go to end of file */
  1584. !             st->st_size = r;
  1585. !             (void)Fseek(0L, fd, SEEK_SET);    /* go to start of file */
  1586. !             /* check for executable file */
  1587. !             if (_x_Bit_set_in_stat && 
  1588. !             Fread(fd, 2, (char *)&magic) == 2) {
  1589. !             if (magic == 0x601a || magic == 0x2321)
  1590. !                 st->st_mode |= 0111;
  1591. !             }
  1592. !             (void)Fseek(oldplace, fd, SEEK_SET);
  1593. !         }
  1594. !         }
  1595. !         
  1596. !         /* all this stuff is likely bogus as well. sigh. */
  1597. !         st->st_dev = Dgetdrv();
  1598. !         st->st_rdev = 0;
  1599. !         st->st_uid = getuid();
  1600. !         st->st_gid = getgid();
  1601. !         st->st_blksize = 1024;
  1602. !         /* note: most Unixes measure st_blocks in 512 byte units */
  1603. !         st->st_blocks = (st->st_size + 511) / 512;
  1604. !         st->st_ino = ++__inode;
  1605. !         st->st_nlink = 1;
  1606. !         return 0;
  1607. !         
  1608. !     }
  1609.       }
  1610.       errno = EBADF;
  1611.       return -1;
  1612. *** 1.7    1991/06/11 23:04:27
  1613. --- symlink.c    1992/01/14 18:51:47
  1614. ***************
  1615. *** 21,27 ****
  1616.       SYMDIR *dir;
  1617.       SYMENTRY *d;
  1618.       char *s;
  1619. !     int r;
  1620.   
  1621.   /* Problem: to TOS, "Makefile", "Makefile", and "makefilefoo" are all
  1622.    * identical. Fortunately, unx2dos can distinguish them, and
  1623. --- 21,27 ----
  1624.       SYMDIR *dir;
  1625.       SYMENTRY *d;
  1626.       char *s;
  1627. !     int r, save_errno;
  1628.   
  1629.   /* Problem: to TOS, "Makefile", "Makefile", and "makefilefoo" are all
  1630.    * identical. Fortunately, unx2dos can distinguish them, and
  1631. ***************
  1632. *** 33,43 ****
  1633. --- 33,45 ----
  1634.    * is redundant).
  1635.    */
  1636.   
  1637. +         save_errno = errno;
  1638.       r = unx2dos(new, linkpath);
  1639.       if ((r == _NM_LINK) || (r == _NM_OK) && !access(new, 0)) {
  1640.           errno = EEXIST;
  1641.           return -1;
  1642.       }
  1643. +     errno = save_errno;
  1644.   
  1645.   /*
  1646.    * find the name (from the original path in "new"), and the canonical form
  1647. ***************
  1648. *** 99,104 ****
  1649. --- 101,107 ----
  1650.       char tmp[FILENAME_MAX], linkpath[FILENAME_MAX], *s, *lastslash = 0;
  1651.       SYMDIR *dir;
  1652.       SYMENTRY *ent;
  1653. +         size_t len;
  1654.   
  1655.       strcpy(tmp, filename);
  1656.       for (s = tmp; *s; s++) {
  1657. ***************
  1658. *** 105,111 ****
  1659.           if (*s == '\\' || (_tSLASH && (*s == '/')))
  1660.               lastslash = s;
  1661.       }
  1662. !     if (lastslash) {
  1663.           *lastslash++ = 0;
  1664.           unx2dos(tmp, linkpath);
  1665.       }
  1666. --- 108,117 ----
  1667.           if (*s == '\\' || (_tSLASH && (*s == '/')))
  1668.               lastslash = s;
  1669.       }
  1670. !         if (lastslash==tmp) {
  1671. !             lastslash++;
  1672. !             unx2dos("/",linkpath);
  1673. !         } else if (lastslash) {
  1674.           *lastslash++ = 0;
  1675.           unx2dos(tmp, linkpath);
  1676.       }
  1677. ***************
  1678. *** 123,128 ****
  1679.           return -1;
  1680.       }
  1681.       strncpy(linkto, ent->linkto, siz);
  1682.       _free_symdir(dir);
  1683. !     return strlen(linkto);
  1684.   }
  1685. --- 129,140 ----
  1686.           return -1;
  1687.       }
  1688.       strncpy(linkto, ent->linkto, siz);
  1689. + 
  1690. +         /* must get length right */
  1691. +         len=strlen(ent->linkto);
  1692. +         if (len>siz) {
  1693. +            len=siz;
  1694. +         }
  1695.       _free_symdir(dir);
  1696. !     return len;
  1697.   }
  1698. *** 1.17    1991/06/23 17:07:09
  1699. --- unlink.c    1992/01/14 18:51:50
  1700. ***************
  1701. *** 13,18 ****
  1702. --- 13,19 ----
  1703.   #include "lib.h"
  1704.   
  1705.   #define error(x) ((errno = (x)), -1)
  1706. + __EXTERN char *strdup __PROTO((const char *s));
  1707.   
  1708.   /* remove provided for ansi compatibility */
  1709.   #ifndef __GNUC__
  1710. ***************
  1711. *** 35,42 ****
  1712.   
  1713.       d = D;
  1714.       while (d) {
  1715.           (void)Fdelete(d->fname);
  1716. !         d = d->next;
  1717.       }
  1718.   }
  1719.   
  1720. --- 36,46 ----
  1721.   
  1722.       d = D;
  1723.       while (d) {
  1724. +         if(d->fname) {
  1725.           (void)Fdelete(d->fname);
  1726. !         free(d->fname);
  1727. !         }
  1728. !         d = d->next;
  1729.       }
  1730.   }
  1731.   
  1732. ***************
  1733. *** 98,105 ****
  1734.                   return error(ENOMEM);
  1735.               }
  1736.       /* hook the new "delete" structure into the chain */
  1737. !             d->fname = name;
  1738.               d->next = D; D = d;
  1739.       /* if there was an automatic link, delete it now */
  1740.               if (ent)
  1741.                   goto unlink_sym;
  1742. --- 102,119 ----
  1743.                   return error(ENOMEM);
  1744.               }
  1745.       /* hook the new "delete" structure into the chain */
  1746. !             d->fname = strdup(name);
  1747.               d->next = D; D = d;
  1748. +             if(!(d->fname)) {
  1749. +                 /* note we link it in and then check, as
  1750. +                    we cannot undo the atexit(), (nor do we
  1751. +                    want to because there maybe others on the
  1752. +                    chain already). in do_deletes we'll
  1753. +                    just skip the null name entries */
  1754. +                 _free_symdir(dir);
  1755. +                 return error(ENOMEM);
  1756. +             }
  1757. +             
  1758.       /* if there was an automatic link, delete it now */
  1759.               if (ent)
  1760.                   goto unlink_sym;
  1761.